JavaScript BigInt-aritmetikk: Et dypdykk i beregninger med store tall og presisjonshåndtering

I mange år sto JavaScript-utviklere overfor en stille, men betydelig begrensning: mangelen på evnen til å representere svært store heltall nøyaktig. Alle tall i JavaScript ble tradisjonelt representert som IEEE 754 flyttall med dobbel presisjon, noe som setter et tak for heltallspresisjon. Når beregninger involverte tall større enn det som kunne håndteres trygt, måtte utviklere ty til tredjepartsbiblioteker. Dette endret seg med introduksjonen av BigInt i ECMAScript 2020 (ES11), en revolusjonerende funksjon som brakte vilkårlig presisjonsheltall inn i kjernespråket.

Denne omfattende guiden er designet for et globalt publikum av utviklere. Vi vil utforske problemene BigInt løser, hvordan man bruker det for presis aritmetikk, dets anvendelser i den virkelige verden innen felt som kryptografi og finans, og de vanlige fallgruvene man bør unngå. Enten du bygger en fintech-plattform, en vitenskapelig simulering, eller samhandler med systemer som bruker 64-bits identifikatorer, er forståelsen av BigInt avgjørende for moderne JavaScript-utvikling.

Glasstaket til JavaScripts `Number`-type

Før vi kan sette pris på løsningen, må vi først forstå problemet. JavaScripts standard Number-type, selv om den er allsidig, har en fundamental begrensning når det gjelder heltallspresisjon. Dette er ikke en feil; det er en direkte konsekvens av designet basert på IEEE 754-standarden for flyttallsaritmetikk.

Forståelse av `Number.MAX_SAFE_INTEGER`

Number-typen kan bare trygt representere heltall opp til en viss verdi. Denne terskelen er eksponert som en statisk egenskap: Number.MAX_SAFE_INTEGER.

Verdien er 9 007 199 254 740 991, eller 2⁵³ - 1. Hvorfor akkurat dette tallet? I de 64 bitene som brukes for et flyttall med dobbel presisjon, er 52 biter dedikert til mantissen (de signifikante sifrene), ett bit for fortegnet, og 11 biter for eksponenten. Denne strukturen tillater et svært stort spekter av verdier, men begrenser den sammenhengende, gapløse representasjonen av heltall.

La oss se hva som skjer når vi prøver å overskride denne grensen:

            
const maxSafeInt = Number.MAX_SAFE_INTEGER;
console.log(maxSafeInt); // 9007199254740991

const oneMore = maxSafeInt + 1;
console.log(oneMore); // 9007199254740992

const twoMore = maxSafeInt + 2;
console.log(twoMore); // 9007199254740992 - Oi da!

console.log(oneMore === twoMore); // true

            

              
                Copy
              
            
          

Som du kan se, mister tallsystemet evnen til å representere hvert påfølgende heltall så snart vi krysser terskelen. maxSafeInt + 1 og maxSafeInt + 2 evalueres til samme verdi. Dette stille tapet av presisjon kan føre til katastrofale feil i applikasjoner som er avhengige av nøyaktig heltallsaritmetikk, som for eksempel finansielle beregninger eller håndtering av store database-ID-er.

Når har dette betydning?

Denne begrensningen er ikke bare en teoretisk kuriositet. Den har betydelige konsekvenser i den virkelige verden:

• Database-ID-er: Mange moderne databasesystemer, som PostgreSQL, bruker en 64-bits heltallstype (BIGINT) for primærnøkler. Disse ID-ene kan lett overstige Number.MAX_SAFE_INTEGER. Når en JavaScript-klient henter denne ID-en, kan den bli avrundet feil, noe som fører til datakorrupsjon eller manglende evne til å hente riktig post.
• API-integrasjoner: Tjenester som Twitter (nå X) bruker 64-bits heltall kalt "Snowflakes" for tweet-ID-er. Å håndtere disse ID-ene korrekt i en JavaScript-frontend krever spesiell oppmerksomhet.
• Kryptografi: Kryptografiske operasjoner involverer ofte aritmetikk med ekstremt store primtall, langt utover kapasiteten til standard Number-typen.
• Høypresisjons tidsstempler: Noen systemer gir tidsstempler med nanosekundpresisjon, ofte representert som et 64-bits heltall som teller fra en epoke. Å lagre dette i en standard Number ville avkortet presisjonen.

Her kommer BigInt: Løsningen for vilkårlig presisjonsheltall

BigInt ble introdusert spesifikt for å løse dette problemet. Det er en separat numerisk primitiv type i JavaScript som kan representere heltall med vilkårlig presisjon. Dette betyr at en BigInt ikke er begrenset av et fast antall biter; den kan vokse eller krympe for å romme verdien den holder, kun begrenset av tilgjengelig minne i vertssystemet.

Opprette en BigInt

Det er to primære måter å opprette en BigInt-verdi på:

1. Legge til `n` etter et heltallsliteral: Dette er den enkleste og vanligste metoden.
2. Bruke konstruktørfunksjonen `BigInt()`: Dette er nyttig for å konvertere strenger eller Numbers til BigInts.

Her er noen eksempler:

            
// Bruker 'n'-suffikset
const aLargeNumber = 9007199254740991n;
const anEvenLargerNumber = 1234567890123456789012345678901234567890n;

// Bruker BigInt()-konstruktøren
const fromString = BigInt("98765432109876543210");
const fromNumber = BigInt(100); // Oppretter 100n

// La oss verifisere typen deres
console.log(typeof aLargeNumber); // "bigint"
console.log(typeof fromString);   // "bigint"

            

              
                Copy
              
            
          

Viktig merknad: Du kan ikke bruke `new`-operatoren med `BigInt()`, da det er en primitiv type, ikke et objekt. `new BigInt()` vil kaste en `TypeError`.

Kjerne-aritmetikk med BigInt

BigInt støtter de standard aritmetiske operatorene du er kjent med, men de oppfører seg strengt innenfor heltallenes domene.

Addisjon, subtraksjon og multiplikasjon

Disse operatorene fungerer akkurat som forventet, men med evnen til å håndtere enorme tall uten å miste presisjon.

            
const num1 = 12345678901234567890n;
const num2 = 98765432109876543210n;

// Addisjon
console.log(num1 + num2); // 111111111011111111100n

// Subtraksjon
console.log(num2 - num1); // 86419753208641975320n

// Multiplikasjon
console.log(num1 * 2n);   // 24691357802469135780n

            

              
                Copy
              
            
          

Divisjon (`/`)

Det er her BigInts oppførsel skiller seg betydelig fra standard Number-divisjon. Fordi BigInts bare kan representere hele tall, blir resultatet av en divisjon alltid avkortet mot null (brøkdelen forkastes).

            
const dividend = 10n;
const divisor = 3n;

console.log(dividend / divisor); // 3n (ikke 3.333...)

const negativeDividend = -10n;
console.log(negativeDividend / divisor); // -3n

// Til sammenligning med Number-divisjon
console.log(10 / 3); // 3.3333333333333335

            

              
                Copy
              
            
          

Denne heltallsdivisjonen er avgjørende. Hvis du trenger å utføre beregninger som krever desimalpresisjon, er BigInt ikke det rette verktøyet. Du må da bruke biblioteker som `Decimal.js` eller håndtere desimaldelen manuelt (for eksempel ved å jobbe med den minste valutaenheten i finansielle beregninger).

Rest (`%`) og eksponentiering (`**`)

Restoperatoren (`%`) og eksponentieringsoperatoren (`**`) fungerer også som forventet med BigInt-verdier.

            
console.log(10n % 3n); // 1n
console.log(-10n % 3n); // -1n

// Eksponentiering kan skape virkelig massive tall
const base = 2n;
const exponent = 100n;
const hugeNumber = base ** exponent;
console.log(hugeNumber); // 1267650600228229401496703205376n

            

              
                Copy
              
            
          

Den strenge regelen: Ikke bland `BigInt` og `Number`

En av de viktigste reglene å huske når du jobber med BigInt er at du ikke kan blande BigInt- og Number-operander i de fleste aritmetiske operasjoner. Et forsøk på å gjøre dette vil resultere i en `TypeError`.

Dette designvalget var bevisst. Det forhindrer utviklere fra å miste presisjon ved et uhell når en BigInt implisitt blir konvertert til en Number. Språket tvinger deg til å være eksplisitt om intensjonene dine.

            
const myBigInt = 100n;
const myNumber = 50;

try {
  const result = myBigInt + myNumber; // Dette vil feile
} catch (error) {
  console.error(error); // TypeError: Kan ikke blande BigInt og andre typer, bruk eksplisitte konverteringer
}

            

              
                Copy
              
            
          

Den korrekte tilnærmingen: Eksplisitt konvertering

For å utføre en operasjon mellom en BigInt og en Number, må du eksplisitt konvertere den ene til den andres type.

            
const myBigInt = 100n;
const myNumber = 50;

// Konverter Number til en BigInt
const result1 = myBigInt + BigInt(myNumber);
console.log(result1); // 150n

// Konverter BigInt til en Number (bruk med forsiktighet!)
const result2 = Number(myBigInt) + myNumber;
console.log(result2); // 150

            

              
                Copy
              
            
          

Advarsel: Å konvertere en BigInt til en Number ved hjelp av `Number()` er farlig hvis BigInt-verdien er utenfor det trygge heltallsområdet. Dette kan gjeninnføre nettopp de presisjonsfeilene som BigInt er designet for å forhindre.

            
const veryLargeBigInt = 9007199254740993n;
const convertedToNumber = Number(veryLargeBigInt);

console.log(veryLargeBigInt);      // 9007199254740993n
console.log(convertedToNumber);  // 9007199254740992 - Presisjon tapt!

            

              
                Copy
              
            
          

Den generelle regelen er: hvis du jobber med potensielt store heltall, hold deg innenfor BigInt-økosystemet for alle beregningene dine. Konverter kun tilbake til en Number hvis du er sikker på at verdien er innenfor det trygge området.

Sammenlignings- og logiske operatorer

Mens aritmetiske operatorer er strenge når det gjelder typeblanding, er sammenlignings- og logiske operatorer mer ettergivende.

Relasjonelle sammenligninger (`>`, `<`, `>=`, `<=`)

Du kan trygt sammenligne en BigInt med en Number. JavaScript vil håndtere sammenligningen av deres matematiske verdier korrekt.

            
console.log(10n > 5);   // true
console.log(10n < 20);  // true
console.log(100n >= 100); // true
console.log(99n <= 100);  // true

            

              
                Copy
              
            
          

Likhet (`==` vs. `===`)

Forskjellen mellom løs likhet (`==`) og streng likhet (`===`) er veldig viktig med BigInt.

• Streng likhet (`===`) sjekker for både verdi og type. Siden `BigInt` og `Number` er forskjellige typer, vil `10n === 10` alltid være false.
• Løs likhet (`==`) utfører typekonvertering. Den vil anse `10n == 10` som true fordi deres matematiske verdier er de samme.

            
console.log(10n == 10);   // true
console.log(10n === 10);  // false (forskjellige typer)
console.log(10n === 10n); // true (samme verdi og type)

            

              
                Copy
              
            
          

For klarhetens skyld og for å unngå uventet oppførsel, er det ofte beste praksis å bruke streng likhet og sørge for at du sammenligner verdier av samme type.

Boolsk kontekst

I likhet med Numbers, kan BigInts evalueres i en boolsk kontekst (f.eks. i en `if`-setning). Verdien `0n` anses som "falsy", mens alle andre BigInt-verdier (positive eller negative) anses som "truthy".

            
if (0n) {
  // Denne koden vil ikke kjøre
} else {
  console.log("0n er falsy");
}

if (1n && -10n) {
  console.log("BigInts som ikke er null er truthy");
}

            

              
                Copy
              
            
          

Praktiske bruksområder for BigInt i en global kontekst

Nå som vi forstår mekanismene, la oss utforske hvor BigInt skinner i reelle, internasjonale applikasjoner.

1. Finansteknologi (FinTech)

Flyttallsaritmetikk er notorisk problematisk for finansielle beregninger på grunn av avrundingsfeil. En vanlig global praksis er å representere pengeverdier som heltall av den minste valutaenheten (f.eks. cent for USD, yen for JPY, satoshis for Bitcoin).

Selv om standard Numbers kan være tilstrekkelig for mindre beløp, blir BigInt uvurderlig når man håndterer store transaksjoner, aggregerte totaler eller kryptovalutaer, som ofte involverer svært store tall.

            
// Representerer en stor overføring i den minste enheten (f.eks. Wei for Ethereum)
const walletBalance = 1234567890123456789012345n; // En stor mengde Wei
const transactionAmount = 9876543210987654321n;

const newBalance = walletBalance - transactionAmount;

console.log(`Ny saldo: ${newBalance.toString()} Wei`);
// Ny saldo: 1224691346912369134691246 Wei

            

              
                Copy
              
            
          

Bruk av BigInt sikrer at hver eneste enhet blir redegjort for, og eliminerer avrundingsfeilene som kan oppstå med flyttallsmatematikk.

2. Kryptografi

Moderne kryptografi, som RSA-algoritmen brukt i TLS/SSL-kryptering på tvers av nettet, er avhengig av aritmetikk med ekstremt store primtall. Disse tallene er ofte 2048 biter eller større, langt utover kapasiteten til JavaScripts Number-type.

Med BigInt kan kryptografiske algoritmer nå implementeres eller polyfylles direkte i JavaScript, noe som åpner for nye muligheter for sikkerhetsverktøy i nettleseren og WebAssembly-drevne applikasjoner.

3. Håndtering av 64-bits identifikatorer

Som nevnt tidligere, genererer mange distribuerte systemer og databaser 64-bits unike identifikatorer. Dette er et vanlig mønster i storskala-systemer utviklet av selskaper over hele verden.

Før BigInt måtte JavaScript-applikasjoner som konsumerte API-er som returnerte disse ID-ene, behandle dem som strenger for å unngå presisjonstap. Dette var en tungvint løsning.

            
// Et API-svar med en 64-bits bruker-ID
const apiResponse = '{"userId": "1143534363363377152", "username": "dev_user"}';

// Gammel måte (parser som streng)
const userDataString = JSON.parse(apiResponse);
console.log(userDataString.userId); // "1143534363363377152"
// All matematikk ville krevd et bibliotek eller strengmanipulering.

// Ny måte (med en tilpasset reviver og BigInt)
const userDataBigInt = JSON.parse(apiResponse, (key, value) => {
  // En enkel sjekk for å konvertere potensielle ID-felt til BigInt
  if (key === 'userId' && typeof value === 'string' && /^[0-9]+$/.test(value)) {
    return BigInt(value);
  }
  return value;
});

console.log(userDataBigInt.userId); // 1143534363363377152n
console.log(typeof userDataBigInt.userId); // "bigint"

            

              
                Copy
              
            
          

Med BigInt kan disse ID-ene representeres som sin korrekte numeriske type, noe som tillater korrekt sortering, sammenligning og lagring.

4. Vitenskapelig og matematisk databehandling

Fagfelt som tallteori, kombinatorikk og fysikksimuleringer krever ofte beregninger som produserer heltall større enn Number.MAX_SAFE_INTEGER. For eksempel kan beregning av store fakulteter eller ledd i Fibonacci-sekvensen gjøres enkelt med BigInt.

            
function factorial(n) {
  // Bruk BigInts fra starten av
  let result = 1n;
  for (let i = 2n; i <= n; i++) {
    result *= i;
  }
  return result;
}

// Beregn fakultetet av 50
const fact50 = factorial(50n);
console.log(fact50.toString());
// 30414093201713378043612608166064768844377641568960512000000000000n

            

              
                Copy
              
            
          

Avanserte emner og vanlige fallgruver

Selv om BigInt er kraftig, er det flere nyanser og potensielle problemer man må være klar over.

JSON-serialisering: En stor fallgruve

En betydelig utfordring oppstår når du prøver å serialisere et objekt som inneholder en BigInt til en JSON-streng. Som standard vil `JSON.stringify()` kaste en `TypeError` når den støter på en BigInt.

            
const data = {
  id: 12345678901234567890n,
  status: "active"
};

try {
  JSON.stringify(data);
} catch (error) {
  console.error(error); // TypeError: Vet ikke hvordan man serialiserer en BigInt
}

            

              
                Copy
              
            
          

Dette er fordi JSON-spesifikasjonen ikke har en datatype for vilkårlig store heltall, og en stille konvertering til et standard tall kan føre til presisjonstap. For å håndtere dette, må du tilby en tilpasset serialiseringsstrategi.

Løsning 1: Implementer en `toJSON`-metode

Du kan legge til en `toJSON`-metode i `BigInt.prototype`. Denne metoden vil automatisk bli kalt av `JSON.stringify()`.

            
// Legg til dette i applikasjonens oppstartsfil
BigInt.prototype.toJSON = function() {
  return this.toString();
};

const data = { id: 12345678901234567890n, status: "active" };
const jsonString = JSON.stringify(data);

console.log(jsonString); // "{"id":"12345678901234567890","status":"active"}"

            

              
                Copy
              
            
          

Løsning 2: Bruk en `replacer`-funksjon

Hvis du ikke vil modifisere en global prototype, kan du sende en `replacer`-funksjon til `JSON.stringify()`.

            
const replacer = (key, value) => {
  if (typeof value === 'bigint') {
    return value.toString();
  }
  return value;
};

const data = { id: 12345678901234567890n, status: "active" };
const jsonString = JSON.stringify(data, replacer);

console.log(jsonString); // "{"id":"12345678901234567890","status":"active"}"

            

              
                Copy
              
            
          

Husk at du også vil trenge en tilsvarende `reviver`-funksjon når du bruker `JSON.parse()` for å konvertere strengrepresentasjonen tilbake til en BigInt, som vist i 64-bits ID-eksempelet tidligere.

Bitvise operasjoner

BigInt støtter også bitvise operasjoner (`&`, `|`, `^`, `~`, `<<`, `>>`), som behandler BigInt som en sekvens av bits i toerkomplement-representasjon. Dette er ekstremt nyttig for lavnivå datamanipulering, parsing av binære protokoller, eller implementering av visse algoritmer.

            
const mask = 0b1111n; // En 4-bits maske
const value = 255n;   // 0b11111111n

// Bitvis AND
console.log(value & mask); // 15n (which is 0b1111n)

// Venstreskift
console.log(1n << 64n); // 18446744073709551616n (2^64)

            

              
                Copy
              
            
          

Merk at den fortegnsløse høyreskiftoperatoren (`>>>`) ikke støttes for BigInt, da hver BigInt er fortegnsbestemt.

Ytelseshensyn

Selv om BigInt er et kraftig verktøy, er det ikke en direkte erstatning for Number. Operasjoner på BigInts er generelt tregere enn sine Number-motstykker fordi de krever mer kompleks, variabel-lengde minneallokering og beregningslogikk. For standard aritmetikk som faller komfortabelt innenfor det trygge heltallsområdet, bør du fortsette å bruke Number-typen for optimal ytelse.

Tommelfingerregelen er enkel: Bruk Number som standard. Bytt til BigInt kun når du vet at du vil håndtere heltall som kan overstige Number.MAX_SAFE_INTEGER.

Nettleser- og miljøstøtte

BigInt er en del av ES2020-standarden og er bredt støttet i alle moderne nettlesere (Chrome, Firefox, Safari, Edge) og server-side miljøer som Node.js (versjon 10.4.0 og senere). Det er imidlertid ikke tilgjengelig i eldre nettlesere som Internet Explorer. Hvis du trenger å støtte eldre miljøer, må du fortsatt stole på tredjeparts biblioteker for store tall og potensielt bruke en transpiler som Babel, som kan tilby en polyfill.

For et globalt publikum er det alltid lurt å sjekke en kompatibilitetsressurs som "Can I Use..." for å sikre at din målgruppe kan kjøre koden din uten problemer.

Konklusjon: En ny grense for JavaScript

Introduksjonen av BigInt markerer en betydelig modning av JavaScript-språket. Det adresserer direkte en langvarig begrensning og gir utviklere mulighet til å bygge en ny klasse applikasjoner som krever høypresisjons heltallsaritmetikk. Ved å tilby en innebygd løsning, eliminerer BigInt behovet for eksterne biblioteker for mange vanlige bruksområder, noe som fører til renere, mer effektiv og sikrere kode.

Viktige punkter for globale utviklere:

• Bruk BigInt for heltall utover 2⁵³ - 1: Når applikasjonen din kan håndtere heltall større enn `Number.MAX_SAFE_INTEGER`, bruk BigInt for å garantere presisjon.
• Vær eksplisitt med typer: Husk at du ikke kan blande `BigInt` og `Number` i aritmetiske operasjoner. Utfør alltid eksplisitte konverteringer og vær oppmerksom på potensielt presisjonstap når du konverterer en stor BigInt tilbake til en Number.
• Mestre JSON-håndtering: Vær forberedt på å håndtere `TypeError` fra `JSON.stringify()`. Implementer en robust serialiserings- og deserialiseringsstrategi ved hjelp av en `toJSON`-metode eller et `replacer`/`reviver`-par.
• Velg riktig verktøy for jobben: BigInt er kun for heltall. For desimal-aritmetikk med vilkårlig presisjon, er biblioteker som `Decimal.js` fortsatt det riktige valget. Bruk `Number` for alle andre ikke-heltalls- eller små heltallsberegninger for å opprettholde ytelsen.

Ved å omfavne BigInt kan det internasjonale JavaScript-fellesskapet nå trygt takle utfordringer innen finans, vitenskap, dataintegritet og kryptografi, og flytte grensene for hva som er mulig på nettet og utover.